import { Request, Response, NextFunction } from 'express';
import { prisma } from '../../config/database';
import { BaseController } from '../../utils/autoBind';
import { ResponseUtils } from '../../utils/responseUtils';
import { BUSINESS_ERROR_CODES, VALIDATION_ERROR_CODES } from '../../utils/errorCodes';
import { v4 as uuidv4 } from 'uuid';
import axios from 'axios';

export class ClientAIAssistantController extends BaseController {
  // AI聊天 - 流式响应
  async chat(req: Request, res: Response, next: NextFunction): Promise<void> {
    try {
      const { message } = req.body;
      const userId = req.user!.id;
      if (!message) {
        ResponseUtils.sendError(res, VALIDATION_ERROR_CODES.REQUIRED_FIELD_MISSING, '消息内容不能为空');
        return;
      }

      // 设置响应头，支持流式传输
      res.setHeader('Content-Type', 'text/event-stream');
      res.setHeader('Cache-Control', 'no-cache');
      res.setHeader('Connection', 'keep-alive');
      res.setHeader('Access-Control-Allow-Origin', '*');
      res.setHeader('Access-Control-Allow-Headers', 'Cache-Control');

      // 使用 DeepSeek API
      const deepseekApiKey = 'sk-23a09ff4d4954c5a93109c807ed00a13';
      let aiResponse = '抱歉，我无法回答这个问题。';
      
      try {
        // 使用流式请求配置
        const data = JSON.stringify({
          messages: [
            {
              content: '你是一个音乐节智能助手，专门帮助用户了解音乐节信息、演出安排、艺人详情、场地导航等内容。请用友好、专业的语气回答用户问题。',
              role: 'system'
            },
            {
              content: message,
              role: 'user'
            }
          ],
          model: 'deepseek-chat',
          frequency_penalty: 0,
          max_tokens: 2048,
          presence_penalty: 0,
          response_format: {
            type: 'text'
          },
          stop: null,
          stream: true, // 启用流式输出
          stream_options: null,
          temperature: 0.7,
          top_p: 1,
          tools: null,
          tool_choice: 'none',
          logprobs: false,
          top_logprobs: null
        });

        const config = {
          method: 'post',
          maxBodyLength: Infinity,
          url: 'https://api.deepseek.com/chat/completions',
          headers: {
            'Content-Type': 'application/json',
            'Accept': 'text/event-stream', // 接受流式响应
            'Authorization': `Bearer ${deepseekApiKey}`
          },
          data: data,
          responseType: 'stream' as const // 设置响应类型为流
        };

        // 发送开始标记
        res.write('data: {"type": "start", "message": "开始生成回复..."}\n\n');

        const response = await axios(config);
        const stream = response.data;
        
        let fullResponse = '';
        
        // 处理流式响应
        stream.on('data', (chunk: Buffer) => {
          const lines = chunk.toString().split('\n');
          
          for (const line of lines) {
            if (line.startsWith('data: ')) {
              const data = line.slice(6);
              if (data === '[DONE]') {
                // 流结束 - 正确转义JSON字符串
                const escapedFullResponse = fullResponse
                  .replace(/\\/g, '\\\\')
                  .replace(/"/g, '\\"')
                  .replace(/\n/g, '\\n')
                  .replace(/\r/g, '\\r')
                  .replace(/\t/g, '\\t');
                res.write(`data: {"type": "end", "message": "${escapedFullResponse}"}\n\n`);
                res.end();
                return;
              }
              
              try {
                const parsed = JSON.parse(data);
                if (parsed.choices && parsed.choices[0] && parsed.choices[0].delta && parsed.choices[0].delta.content) {
                  const content = parsed.choices[0].delta.content;
                  fullResponse += content;
                  console.log(content,"content");
                  // 发送部分响应 - 正确转义JSON字符串
                  const escapedContent = content
                    .replace(/\\/g, '\\\\')
                    .replace(/"/g, '\\"')
                    .replace(/\n/g, '\\n')
                    .replace(/\r/g, '\\r')
                    .replace(/\t/g, '\\t');
                  res.write(`data: {"type": "chunk", "message": "${escapedContent}"}\n\n`);
                }
              } catch (e) {
                // 忽略解析错误
              }
            }
          }
        });

        stream.on('end', async () => {
          // 保存完整的对话记录
          try {
            let conversation = await prisma.assistantConversation.findFirst({
              where: { userId: userId }
            });

            if (!conversation) {
              conversation = await prisma.assistantConversation.create({
                data: {
                  userId: userId,
                  sessionId: uuidv4()
                }
              });
            }

            // 保存用户消息
            await prisma.assistantMessage.create({
              data: {
                conversationId: conversation.id,
                messageType: 'USER',
                content: message,
                messageFormat: 'TEXT'
              }
            });

            // 保存AI回复
            await prisma.assistantMessage.create({
              data: {
                conversationId: conversation.id,
                messageType: 'ASSISTANT',
                content: fullResponse,
                messageFormat: 'TEXT'
              }
            });
          } catch (dbError) {
            console.error('保存对话记录失败:', dbError);
          }
        });

        stream.on('error', (error: any) => {
          console.error('流式响应错误:', error);
          res.write('data: {"type": "error", "message": "抱歉，AI服务出现错误，请稍后再试。"}\n\n');
          res.end();
        });

      } catch (error: any) {
        console.error('DeepSeek API 调用失败:', error);
        
        // 检查错误类型并发送错误响应
        if (error.response?.status === 402) {
          console.error('API Key 问题：可能是余额不足、Key 无效或权限不足');
          res.write('data: {"type": "error", "message": "抱歉，AI 服务暂时不可用。请稍后再试或联系管理员。"}\n\n');
        } else if (error.response?.status === 401) {
          console.error('API Key 认证失败');
          res.write('data: {"type": "error", "message": "AI 服务认证失败，请检查配置。"}\n\n');
        } else if (error.response?.status === 429) {
          console.error('API 调用频率过高');
          res.write('data: {"type": "error", "message": "AI 服务繁忙，请稍后再试。"}\n\n');
        } else {
          console.error('其他 API 错误:', error.response?.status, error.response?.data);
          // Fallback to simulated response
          const lowerMessage = message.toLowerCase();
          if (lowerMessage.includes('你好') || lowerMessage.includes('hello')) {
            aiResponse = '您好！我是音乐节智能助手，很高兴为您服务。我可以帮您查询演出信息、艺人详情、场地导航等。请问有什么可以帮您的吗？';
          } else if (lowerMessage.includes('演出') || lowerMessage.includes('表演')) {
            aiResponse = '您可以在演出列表页面查看所有演出信息，包括演出时间、地点和艺人详情。需要我为您推荐一些热门演出吗？';
          } else if (lowerMessage.includes('艺人') || lowerMessage.includes('歌手')) {
            aiResponse = '您可以在艺人页面浏览所有参与音乐节的艺人信息，包括他们的作品、演出安排和粉丝互动。';
          } else if (lowerMessage.includes('场地') || lowerMessage.includes('位置')) {
            aiResponse = '音乐节场地信息包括主舞台、副舞台、休息区、餐饮区等。您可以使用导航功能查找具体位置。';
          } else if (lowerMessage.includes('天气')) {
            aiResponse = '建议您查看当地天气预报，音乐节期间天气多变，请做好防晒和防雨准备。';
          } else if (lowerMessage.includes('票务') || lowerMessage.includes('门票')) {
            aiResponse = '票务信息请关注官方公告，建议通过官方渠道购票以确保安全。';
          } else if (lowerMessage.includes('冷知识') || lowerMessage.includes('有趣')) {
            aiResponse = '音乐节冷知识：世界上第一个现代音乐节是1967年的蒙特雷流行音乐节，它开创了户外大型音乐演出的先河。音乐节不仅是一种娱乐形式，更是文化交流的重要平台。';
          } else {
            aiResponse = '感谢您的提问！我是音乐节智能助手，可以帮您了解演出信息、艺人详情、场地导航等内容。如果您有具体问题，请随时告诉我。';
          }
          
          // 模拟流式输出
          res.write('data: {"type": "start", "message": "使用备用回复..."}\n\n');
          for (let i = 0; i < aiResponse.length; i += 10) {
            const chunk = aiResponse.slice(i, i + 10);
            // 正确转义JSON字符串
            const escapedChunk = chunk
              .replace(/\\/g, '\\\\')
              .replace(/"/g, '\\"')
              .replace(/\n/g, '\\n')
              .replace(/\r/g, '\\r')
              .replace(/\t/g, '\\t');
            res.write(`data: {"type": "chunk", "message": "${escapedChunk}"}\n\n`);
            await new Promise(resolve => setTimeout(resolve, 50)); // 模拟打字效果
          }
          // 正确转义完整的响应
          const escapedAiResponse = aiResponse
            .replace(/\\/g, '\\\\')
            .replace(/"/g, '\\"')
            .replace(/\n/g, '\\n')
            .replace(/\r/g, '\\r')
            .replace(/\t/g, '\\t');
          res.write(`data: {"type": "end", "message": "${escapedAiResponse}"}\n\n`);
        }
        res.end();
      }
    } catch (error) {
      next(error);
    }
  }

  // 获取聊天历史
  async getChatHistory(req: Request, res: Response, next: NextFunction): Promise<void> {
    try {
      const userId = req.user!.id;
      const { page = 1, pageSize = 20 } = req.query;
      const skip = (Number(page) - 1) * Number(pageSize);

      // 获取会话
      const conversation = await prisma.assistantConversation.findFirst({
        where: {
          userId: userId
        },
        include: {
          messages: {
            skip: skip,
            take: Number(pageSize),
            orderBy: {
              createdAt: 'desc'
            }
          }
        }
      });

      const messages = conversation?.messages || [];
      const total = await prisma.assistantMessage.count({
        where: {
          conversation: {
            userId: userId
          }
        }
      });

      ResponseUtils.success(res, {
        items: messages,
        pagination: {
          total,
          page: Number(page),
          pageSize: Number(pageSize),
          totalPages: Math.ceil(total / Number(pageSize))
        }
      }, '获取聊天历史成功');
    } catch (error) {
      next(error);
    }
  }

  // 生成图片
  async generateImage(req: Request, res: Response, next: NextFunction): Promise<void> {
    try {
      const { prompt } = req.body;
      const userId = req.user?.id;
      if (!userId) {
        ResponseUtils.sendError(res, BUSINESS_ERROR_CODES.USER_NOT_FOUND, '用户不存在');
        return;
      }

      if (!prompt) {
        ResponseUtils.sendError(res, VALIDATION_ERROR_CODES.REQUIRED_FIELD_MISSING, '提示词不能为空');
        return;
      }

      // 使用 DeepSeek API 生成图片
      // const deepseekApiKey = 'sk-6ed97a50b703414883d26bced945e9d5';
      let imageUrl = '';
      
      try {
        // 注意：DeepSeek 目前可能不支持图片生成，使用占位图片
        console.log('DeepSeek 图片生成功能暂未支持，使用占位图片');
        imageUrl = 'https://via.placeholder.com/1024x1024/667eea/ffffff?text=AI+Generated+Image';
        
        // 如果将来支持图片生成，可以使用以下代码：
        /*
        const response = await axios.post('https://api.deepseek.com/images/generations', {
          model: 'deepseek-image',
          prompt: prompt,
          n: 1,
          size: '1024x1024'
        }, {
          headers: {
            'Authorization': `Bearer ${deepseekApiKey}`,
            'Content-Type': 'application/json'
          }
        });

        imageUrl = response.data.data?.[0]?.url || '';
        */
      } catch (error) {
        console.error('DeepSeek 图片生成 API 调用失败:', error);
        // 如果 API 调用失败，使用占位图片
        imageUrl = 'https://via.placeholder.com/1024x1024/667eea/ffffff?text=AI+Generated+Image';
      }
      // 创建或获取会话
      let conversation = await prisma.assistantConversation.findFirst({
        where: {
          userId: userId
        }
      });

      if (!conversation) {
        conversation = await prisma.assistantConversation.create({
          data: {
            userId: userId,
            sessionId: uuidv4()
          }
        });
      }

      // 保存图片生成记录到消息中
      await prisma.assistantMessage.create({
        data: {
          conversationId: conversation.id,
          messageType: 'ASSISTANT',
          content: `图片已生成: ${imageUrl}`,
          messageFormat: 'IMAGE'
        }
      });

      ResponseUtils.success(res, {
        imageUrl: imageUrl
      }, '图片生成成功');
    } catch (error) {
      next(error);
    }
  }

  // 获取快捷操作
  async getQuickActions(req: Request, res: Response, next: NextFunction): Promise<void> {
    try {
      const userId = req.user?.id;
      if (!userId) {
        ResponseUtils.sendError(res, BUSINESS_ERROR_CODES.USER_NOT_FOUND, '用户不存在');
        return;
      }

      // 定义快捷操作列表
      const quickActions = [
        {
          id: '1',
          title: '音乐节信息',
          description: '获取音乐节基本信息和日程安排',
          icon: 'Calendar',
          action: 'info',
          color: '#667eea'
        },
        {
          id: '2',
          title: '场地导航',
          description: '查找场地位置和设施信息',
          icon: 'Location',
          action: 'navigation',
          color: '#45b7d1'
        },
        {
          id: '3',
          title: '艺人查询',
          description: '搜索艺人信息和演出安排',
          icon: 'User',
          action: 'artist',
          color: '#ff6b6b'
        },
        {
          id: '4',
          title: '演出推荐',
          description: '获取个性化演出推荐',
          icon: 'VideoPlay',
          action: 'recommendation',
          color: '#4ecdc4'
        },
        {
          id: '5',
          title: '天气查询',
          description: '查看音乐节期间天气情况',
          icon: 'Sunny',
          action: 'weather',
          color: '#f7b731'
        },
        {
          id: '6',
          title: '冷知识分享',
          description: '有趣的音乐节冷知识',
          icon: 'QuestionFilled',
          action: 'trivia',
          color: '#a55eea'
        }
      ];

      ResponseUtils.success(res, quickActions, '获取快捷操作成功');
    } catch (error) {
      next(error);
    }
  }

  // 语音转文字
  async voiceToText(req: Request, res: Response, next: NextFunction): Promise<void> {
    try {
      const userId = req.user?.id;
      if (!userId) {
        ResponseUtils.sendError(res, BUSINESS_ERROR_CODES.USER_NOT_FOUND, '用户不存在');
        return;
      }

      if (!req.file) {
        ResponseUtils.sendError(res, VALIDATION_ERROR_CODES.REQUIRED_FIELD_MISSING, '请上传音频文件');
        return;
      }

      // 这里应该集成实际的语音转文字服务
      // 以下是示例代码，实际项目中需要替换为真实的API调用
      // 例如：使用 OpenAI Whisper API 或其他语音识别服务
      
      // 模拟语音转文字结果
      const text = '这是从语音转换而来的文字内容。实际项目中需要调用语音识别API。';

      ResponseUtils.success(res, {
        text: text
      }, '语音转文字成功');
    } catch (error) {
      next(error);
    }
  }

  // 提问
  // 提问 - 流式响应
  async askQuestion(req: Request, res: Response, next: NextFunction): Promise<void> {
    try {
      const { question } = req.body;
      const userId = req.user?.id;
      if (!userId) {
        ResponseUtils.sendError(res, BUSINESS_ERROR_CODES.USER_NOT_FOUND, '用户不存在');
        return;
      }

      if (!question) {
        ResponseUtils.sendError(res, VALIDATION_ERROR_CODES.REQUIRED_FIELD_MISSING, '问题不能为空');
        return;
      }

      // 设置响应头，支持流式传输
      res.setHeader('Content-Type', 'text/event-stream');
      res.setHeader('Cache-Control', 'no-cache');
      res.setHeader('Connection', 'keep-alive');
      res.setHeader('Access-Control-Allow-Origin', '*');
      res.setHeader('Access-Control-Allow-Headers', 'Cache-Control');

      // 使用 DeepSeek API
      const deepseekApiKey = 'sk-23a09ff4d4954c5a93109c807ed00a13';
      let answer = '抱歉，我无法回答这个问题。';
      
      try {
        // 使用流式请求配置
        const data = JSON.stringify({
          messages: [
            {
              content: '你是一个音乐节智能助手，专门帮助用户了解音乐节信息、演出安排、艺人详情、场地导航等内容。请用友好、专业的语气回答用户问题。',
              role: 'system'
            },
            {
              content: question,
              role: 'user'
            }
          ],
          model: 'deepseek-chat',
          frequency_penalty: 0,
          max_tokens: 2048,
          presence_penalty: 0,
          response_format: {
            type: 'text'
          },
          stop: null,
          stream: true, // 启用流式输出
          stream_options: null,
          temperature: 0.7,
          top_p: 1,
          tools: null,
          tool_choice: 'none',
          logprobs: false,
          top_logprobs: null
        });

        const config = {
          method: 'post',
          maxBodyLength: Infinity,
          url: 'https://api.deepseek.com/chat/completions',
          headers: {
            'Content-Type': 'application/json',
            'Accept': 'text/event-stream', // 接受流式响应
            'Authorization': `Bearer ${deepseekApiKey}`
          },
          data: data,
          responseType: 'stream' as const // 设置响应类型为流
        };

        // 发送开始标记
        res.write('data: {"type": "start", "message": "开始生成回复..."}\n\n');

        const response = await axios(config);
        const stream = response.data;
        
        let fullResponse = '';
        
        // 处理流式响应
        stream.on('data', (chunk: Buffer) => {
          const lines = chunk.toString().split('\n');
          
          for (const line of lines) {
            if (line.startsWith('data: ')) {
              const data = line.slice(6);
              if (data === '[DONE]') {
                // 流结束
                res.write(`data: {"type": "end", "message": "${fullResponse}"}\n\n`);
                res.end();
                return;
              }
              
              try {
                const parsed = JSON.parse(data);
                if (parsed.choices && parsed.choices[0] && parsed.choices[0].delta && parsed.choices[0].delta.content) {
                  const content = parsed.choices[0].delta.content;
                  fullResponse += content;
                  
                  // 发送部分响应
                  res.write(`data: {"type": "chunk", "message": "${content}"}\n\n`);
                }
              } catch (e) {
                // 忽略解析错误
              }
            }
          }
        });

        stream.on('end', async () => {
          // 保存完整的对话记录
          try {
            let conversation = await prisma.assistantConversation.findFirst({
              where: { userId: userId }
            });

            if (!conversation) {
              conversation = await prisma.assistantConversation.create({
                data: {
                  userId: userId,
                  sessionId: uuidv4()
                }
              });
            }

            // 保存用户消息
            await prisma.assistantMessage.create({
              data: {
                conversationId: conversation.id,
                messageType: 'USER',
                content: question,
                messageFormat: 'TEXT'
              }
            });

            // 保存AI回复
            await prisma.assistantMessage.create({
              data: {
                conversationId: conversation.id,
                messageType: 'ASSISTANT',
                content: fullResponse,
                messageFormat: 'TEXT'
              }
            });
          } catch (dbError) {
            console.error('保存对话记录失败:', dbError);
          }
        });

        stream.on('error', (error: any) => {
          console.error('流式响应错误:', error);
          res.write('data: {"type": "error", "message": "抱歉，AI服务出现错误，请稍后再试。"}\n\n');
          res.end();
        });

      } catch (error: any) {
        console.error('DeepSeek API 调用失败:', error);
        
        // 检查错误类型并发送错误响应
        if (error.response?.status === 402) {
          console.error('API Key 问题：可能是余额不足、Key 无效或权限不足');
          res.write('data: {"type": "error", "message": "抱歉，AI 服务暂时不可用。请稍后再试或联系管理员。"}\n\n');
        } else if (error.response?.status === 401) {
          console.error('API Key 认证失败');
          res.write('data: {"type": "error", "message": "AI 服务认证失败，请检查配置。"}\n\n');
        } else if (error.response?.status === 429) {
          console.error('API 调用频率过高');
          res.write('data: {"type": "error", "message": "AI 服务繁忙，请稍后再试。"}\n\n');
        } else {
          console.error('其他 API 错误:', error.response?.status, error.response?.data);
          // 如果 API 调用失败，使用模拟回复
          const lowerQuestion = question.toLowerCase();
          
          if (lowerQuestion.includes('音乐节') || lowerQuestion.includes('festival')) {
            answer = '这是一个精彩的音乐节！我们邀请了众多知名艺人和乐队，为您带来难忘的音乐体验。';
          } else if (lowerQuestion.includes('时间') || lowerQuestion.includes('schedule')) {
            answer = '音乐节将持续3天，每天从下午2点开始到晚上11点结束。具体演出时间表请查看演出列表。';
          } else if (lowerQuestion.includes('艺人') || lowerQuestion.includes('artist')) {
            answer = '我们邀请了来自不同音乐风格的优秀艺人，包括流行、摇滚、电子等。您可以在艺人页面查看详细信息。';
          } else if (lowerQuestion.includes('票务') || lowerQuestion.includes('ticket')) {
            answer = '票务信息请关注官方公告，建议通过官方渠道购票以确保安全。';
          } else {
            answer = '感谢您的提问！我是音乐节智能助手，可以帮您了解演出信息、艺人详情、场地导航等内容。如果您有具体问题，请随时告诉我。';
          }
          
          // 模拟流式输出
          res.write('data: {"type": "start", "message": "使用备用回复..."}\n\n');
          for (let i = 0; i < answer.length; i += 10) {
            const chunk = answer.slice(i, i + 10);
            res.write(`data: {"type": "chunk", "message": "${chunk}"}\n\n`);
            await new Promise(resolve => setTimeout(resolve, 50)); // 模拟打字效果
          }
          res.write(`data: {"type": "end", "message": "${answer}"}\n\n`);
        }
        res.end();
      }
    } catch (error) {
      next(error);
    }
  }
}